/*
package com.tongcao.cn.util;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Vector;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.jcraft.jsch.Channel;
import com.jcraft.jsch.ChannelExec;
import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.ChannelSftp.LsEntry;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.Session;
import com.jcraft.jsch.SftpATTRS;
import com.jcraft.jsch.SftpException;

*/
/**
 * sftp工具。注意：构造方法有两个：分别是基于密码认证、基于秘钥认证。
 * 
 * @author wangxf by 2016/05/12
 *
 *//*

public class SFTPUtil {

	private static final Logger LOG = LoggerFactory.getLogger(SFTPUtil.class);
	static final Pattern pattern = Pattern.compile("\\\\");
	private ChannelSftp sftp;
	private String userName; // FTP 登录用户名
	private String password; // FTP 登录密码
	private String keyFilePath;// 私钥文件的路径
	private String host; // FTP 服务器地址IP地址
	private int port; // FTP 端口
	private Session sshSession;

	*/
/**
	 * 构造基于密码认证的sftp对象
	 * 
	 * @param userName
	 *            用户名
	 * @param password
	 *            登陆密码
	 * @param host
	 *            服务器ip
	 * @param port
	 *            fwq端口
	 *//*

	public SFTPUtil(String userName, String password, String host, int port) {
		super();
		this.userName = userName;
		this.password = password;
		this.host = host;
		this.port = port;
	}

	*/
/**
	 * 构造基于秘钥认证的sftp对象
	 * 
	 * @param userName
	 *            用户名
	 * @param host
	 *            服务器ip
	 * @param port
	 *            fwq端口
	 * @param keyFilePath
	 *            私钥文件路径
	 *//*

	public SFTPUtil(String userName, String host, int port, String keyFilePath) {
		super();
		this.userName = userName;
		this.host = host;
		this.port = port;
		this.keyFilePath = keyFilePath;
	}

	*/
/**
	 * 连接sftp服务器
	 * 
	 * @throws Exception
	 *//*

	public void connect() throws Exception {
		try {
			JSch jsch = new JSch();
			if (keyFilePath != null) {
				jsch.addIdentity(keyFilePath);// 设置私钥
				LOG.info("连接sftp，私钥文件路径：" + keyFilePath);
			}
			LOG.info("sftp host: " + host + "; userName:" + userName);

			sshSession = jsch.getSession(userName, host, port);
			LOG.debug("Session 已建立.");
			if (password != null) {
				sshSession.setPassword(password);
			}
			Properties sshConfig = new Properties();
			sshConfig.put("StrictHostKeyChecking", "no");
			sshSession.setConfig(sshConfig);
			sshSession.connect();
			LOG.debug("Session 已连接.");
			Channel channel = sshSession.openChannel("sftp");
			channel.connect();

			sftp = (ChannelSftp) channel;
			LOG.info("连接到SFTP成功。host: " + host);
		} catch (Exception e) {
			LOG.error("连接sftp失败！", e);
			if (sftp != null) {
				if (sftp.isConnected()) {
					sftp.disconnect();
				}
			}
			if (sshSession != null && sshSession.isConnected()) {
				sshSession.disconnect();
			}
			LOG.error("sftp 已经关闭", e);
			throw e;
		}
	}

	*/
/**
	 * 关闭连接 server
	 *//*

	public void disconnect() {
		if (sftp != null) {
			if (sftp.isConnected()) {
				sftp.disconnect();
			} else if (sftp.isClosed()) {
			}
		}
		if (sshSession != null && sshSession.isConnected()) {
			sshSession.disconnect();
		}
		LOG.info("sftp 已经关闭");
	}

	*/
/**
	 * 连接状态.
	 * 
	 * @param sftp
	 * @return
	 *//*

	public boolean isConnected() {
		return (sftp != null) && sftp.isConnected() && !sftp.isClosed()
				&& (sshSession != null) && sshSession.isConnected();
	}

	*/
/**
	 * 获得指定目录结构，返回Vector，里面实际放的LsEntry
	 * 
	 * @param dir
	 * @param sftp
	 * @return
	 *//*

	@SuppressWarnings("rawtypes")
	public Vector _list(String dir) {
		try {
			return sftp.ls(dir);
		} catch (Exception e) {
			return null;
		}
	}

	*/
/**
	 * 获取当前目录结构
	 * 
	 * @param sftp
	 * @return
	 *//*

	@SuppressWarnings("rawtypes")
	public Vector _list() {
		try {
			return sftp.ls(sftp.pwd());
		} catch (Exception e) {
			return null;
		}
	}

	*/
/**
	 * 获取指定目录结构，返回List，每个list里面包含文件或文件夹的名字(name)、是否为文件夹(dir)
	 * 
	 * @param dir
	 * @param sftp
	 * @return
	 *//*

	@SuppressWarnings("rawtypes")
	public List list(String dir) {
		try {
			Vector ls = _list(dir);
			return _buildFiles(ls);
		} catch (Exception e) {
			return null;
		}
	}

	*/
/**
	 * 获取指定目录结构，返回List，每个list里面包含文件或文件夹的名字(name)、是否为文件夹(dir)
	 * 
	 * @param ls
	 * @return
	 * @throws Exception
	 *//*

	@SuppressWarnings({ "rawtypes", "unchecked" })
	public List _buildFiles(Vector ls) throws Exception {
		List list = new ArrayList();
		if (ls != null && ls.size() >= 0) {
			for (int i = 0; i < ls.size(); i++) {
				LsEntry f = (LsEntry) ls.get(i);
				String nm = f.getFilename();
				if (nm.equals(".") || nm.equals(".."))
					continue;
				SftpATTRS attr = f.getAttrs();
				Map m = new HashMap();
				// 判断是否是文件夹
				if (attr.isDir()) {
					m.put("dir", new Boolean(true));
				} else {
					m.put("dir", new Boolean(false));
				}
				m.put("name", nm);
				// 作为扩展字段，能够获取到文件或文件夹的一些属性信息，后面可以根据这个字段获取文件或文件夹的大小
				m.put("attrs", attr);
				list.add(m);
			}
		}
		return list;
	}

	*/
/**
	 * 获取根目录结构，返回List，每个list里面包含文件或文件夹的名字(name)、是否为文件夹(dir)
	 * 
	 * @param sftp
	 * @return
	 *//*

	@SuppressWarnings("rawtypes")
	public List list() {
		try {
			Vector ls = _list();
			return _buildFiles(ls);
		} catch (Exception e) {
			return null;
		}
	}

	*/
/**
	 * 进入指定目录
	 * 
	 * @param dirs
	 * @param sftp
	 * @return
	 * @throws Exception
	 *//*

	public boolean cd(String dirs) throws Exception {
		try {
			String path = dirs;
			// if (path.indexOf("\\\\") != -1) {
			// path = dirs.replaceAll("\\\\", "/");
			// }
			Matcher m = pattern.matcher(path);
			path = m.replaceAll("/");
			// String pwd = sftp.pwd();
			// if (pwd.equals(path))
			// return true;
			if (path.indexOf("/") == 0) {
				// 出现在第一个位置，证明是根目录
				sftp.cd("/");
			}
			String[] paths = path.split("/");
			for (int i = 0; i < paths.length; i++) {
				String dir = paths[i];
				if (isEmpty(dir))
					continue;
				sftp.cd(dir);
			}
			return true;
		} catch (Exception e) {
			throw e;
		}
	}

	*/
/**
	 * 判断字符串是否为空
	 * 
	 * @param s
	 * @return
	 *//*

	public boolean isEmpty(String s) {
		return s == null || "".equals(s.trim());
	}

	*/
/**
	 * 在root文件夹中查找fileOrDir文件夹或文件
	 * 
	 * @param root
	 * @param fileOrDir
	 * @param sftp
	 * @return
	 * @throws Exception
	 *//*


	@SuppressWarnings("rawtypes")
	public boolean isExist(String root, String fileOrDir) throws Exception {
		try {
			boolean exist = false;
			boolean cdflg = false;
			String pwd = sftp.pwd();
			if (pwd.indexOf(root) == -1) {
				cdflg = true;
				sftp.cd(root);
			}
			Vector ls = _list(root);
			if (ls == null || ls.size() <= 0) {
				for (int i = 0; i < ls.size(); i++) {
					LsEntry f = (LsEntry) ls.get(i);
					String nm = f.getFilename();
					if (nm.equals(fileOrDir)) {
						exist = true;
						break;
					}
				}
			}
			if (cdflg) {
				sftp.cd("..");
			}
			return exist;
		} catch (Exception e) {
			throw e;
		}
	}

	*/
/**
	 * 上传文件，sftp端文件名和本地一致，并且上传到当前所在目录
	 * 
	 * @param uploadFile
	 * @param sftp
	 * @return
	 * @throws Exception
	 *//*

	public boolean upload(String uploadFile) throws Exception {
		InputStream is = null;
		try {
			File file = new File(uploadFile);
			is = new FileInputStream(file);
			// 第二个参数sftp端文件名
			sftp.put(is, file.getName());
			return true;
		} catch (Exception e) {
			throw e;
		} finally {
			try {
				if (is != null) {
					is.close();
					is = null;
				}
			} catch (Exception e2) {
				e2.printStackTrace();
			}
		}
	}

	*/
/**
	 * 将输入流的数据上传到sftp作为文件
	 * 
	 * @param directory
	 *            上传到该目录
	 * @param sftpFileName
	 *            sftp端文件名
	 * @param in
	 *            输入流
	 * @throws Exception
	 *//*

	public void upload(String directory, String sftpFileName, InputStream input)
			throws Exception {
		try {

			try {// 如果cd报异常，说明目录不存在，就创建目录
				sftp.cd(directory);
			} catch (Exception e) {
				sftp.mkdir(directory);
				sftp.cd(directory);
			}
			sftp.put(input, sftpFileName);
			LOG.info("sftp上传成功！文件名：" + sftpFileName);
		} catch (Exception e) {
			LOG.error("sftp上传失败！文件名" + sftpFileName, e);
			throw e;
		}
	}

	*/
/**
	 * 上传单个文件
	 * 
	 * @param directory
	 *            上传到sftp目录
	 * @param uploadFile
	 *            要上传的文件,包括路径
	 * @throws Exception
	 *//*

	public void upload(String directory, String uploadFile) throws Exception {
		File file = new File(uploadFile);
		upload(directory, file.getName(), new FileInputStream(file));
	}

	*/
/**
	 * 将byte[]上传到sftp，作为文件。注意:从String生成byte[]是，要指定字符集。
	 * 
	 * @param directory
	 *            上传到sftp目录
	 * @param sftpFileName
	 *            文件在sftp端的命名
	 * @param byteArr
	 *            要上传的字节数组
	 * @throws Exception
	 *//*

	public void upload(String directory, String sftpFileName, byte[] byteArr)
			throws Exception {
		upload(directory, sftpFileName, new ByteArrayInputStream(byteArr));
	}

	*/
/**
	 * 将字符串按照指定的字符编码上传到sftp
	 * 
	 * @param directory
	 *            上传到sftp目录
	 * @param sftpFileName
	 *            文件在sftp端的命名
	 * @param dataStr
	 *            待上传的数据
	 * @param charsetName
	 *            sftp上的文件，按该字符编码保存
	 * @throws Exception
	 *//*

	public void upload(String directory, String sftpFileName, String dataStr,
			String charsetName) throws Exception {
		upload(directory, sftpFileName,
				new ByteArrayInputStream(dataStr.getBytes(charsetName)));

	}

	*/
/**
	 * 下载文件
	 * 
	 * @param directory
	 *            下载目录
	 * @param downloadFile
	 *            下载的文件
	 * @param saveFile
	 *            存在本地的路径
	 * @throws Exception
	 *//*

	public void download(String directory, String downloadFile, String saveFile)
			throws Exception {
		FileOutputStream fos = null;
		try {
			if (directory != null && !"".equals(directory)) {
				cd(directory);
			}
			File file = new File(saveFile + File.separator + downloadFile);
			fos = new FileOutputStream(file);
			sftp.get(downloadFile, fos);
			fos.flush();
			LOG.info("sftp下载文件成功！文件名" + downloadFile);
		} catch (Exception e) {
			LOG.error("sftp下载文件失败！文件名：" + downloadFile, e);
			throw e;
		} finally {
			if (fos != null) {
				fos.close();
			}
		}
	}

	*/
/**
	 * 下载文件
	 * 
	 * @param directory
	 *            下载目录
	 * @param downloadFile
	 *            下载的文件名
	 * @return 字节数组
	 * @throws Exception
	 *//*

	public byte[] download(String directory, String downloadFile)
			throws Exception {
		byte[] fileData = null;
		try {
			if (directory != null && !"".equals(directory)) {
				sftp.cd(directory);
			}
			InputStream is = sftp.get(downloadFile);

			fileData = new byte[is.available()];
			is.read(fileData);

			LOG.info("sftp下载文件成功！文件名" + downloadFile);
		} catch (SftpException e) {
			LOG.error("sftp下载文件失败！文件名：" + downloadFile, e);
			throw e;
		} catch (IOException e) {
			LOG.error("sftp下载文件读取失败！文件名：" + downloadFile, e);
			throw e;
		}
		return fileData;
	}

	*/
/**
	 * 删除文件
	 * 
	 * @param directory
	 *            要删除文件所在目录
	 * @param deleteFile
	 *            要删除的文件
	 * @throws Exception
	 *//*

	public void delete(String directory, String deleteFile) throws Exception {
		try {
			sftp.cd(directory);
			sftp.rm(deleteFile);
		} catch (Exception e) {
			LOG.error("sftp删除文件失败" + deleteFile, e);
			throw e;
		}
	}

	*/
/**
	 * 创建文件夹，并且进入此文件夹
	 * 
	 * @param filepath
	 * @return
	 * @throws Exception
	 *//*

	@SuppressWarnings("rawtypes")
	public boolean mkDir(String filepath) throws Exception {
		try {
			String path = filepath;
			if (path.indexOf("\\") != -1) {
				path = filepath.replaceAll("\\", "/");
			}
			String[] paths = path.split("/");
			for (int i = 0; i < paths.length; i++) {
				String dir = paths[i];
				Vector ls = _list(dir);
				if (ls == null || ls.size() <= 0) {
					sftp.mkdir(dir);
				}
				sftp.cd(dir);
			}
		} catch (Exception e1) {
			throw e1;
		}
		return true;
	}

	*/
/**
	 * 删除当前所在目录的指定文件
	 * 
	 * @param deleteFile
	 * @return
	 * @throws Exception
	 *//*

	@SuppressWarnings("rawtypes")
	public boolean rm(String deleteFile) throws Exception {
		try {
			Vector ls = _list();
			if (ls != null && ls.size() > 0) {
				for (int i = 0; i < ls.size(); i++) {
					LsEntry f = (LsEntry) ls.get(i);
					String nm = f.getFilename();
					if (!nm.equals(deleteFile)) {
						continue;
					}
					SftpATTRS attr = f.getAttrs();
					if (attr.isDir()) {
						if (rmdir(nm)) {
							sftp.rmdir(nm);
						}
					} else {
						sftp.rm(nm);
					}
				}
			}
			return true;
		} catch (Exception e) {
			throw e;
		}
	}

	*/
/**
	 * 删除指定文件夹下的所有文件
	 * 
	 * @param dir
	 * @return
	 * @throws Exception
	 *//*

	@SuppressWarnings("rawtypes")
	public boolean rmdir(String dir) throws Exception {
		try {
			sftp.cd(dir);
			Vector ls = _list();
			if (ls != null && ls.size() > 0) {
				for (int i = 0; i < ls.size(); i++) {
					LsEntry f = (LsEntry) ls.get(i);
					String nm = f.getFilename();
					if (nm.equals(".") || nm.equals(".."))
						continue;
					SftpATTRS attr = f.getAttrs();
					if (attr.isDir()) {
						if (rmdir(nm)) {
							sftp.rmdir(nm);
						}
					} else {
						sftp.rm(nm);
					}
				}
			}
			return true;
		} catch (Exception e) {
			throw e;
		}
	}

	public String execCmd(String command, String user) throws Exception {
		try {
			String result = "";
			if (command != null) {
				Channel channel = sshSession.openChannel("exec");
				((ChannelExec) channel).setCommand(command);
				channel.setInputStream(null);
				((ChannelExec) channel).setErrStream(System.err);
				channel.connect();
				InputStream in = channel.getInputStream();
				BufferedReader reader = new BufferedReader(
						new InputStreamReader(in));
				String buf = null;
				
				while ((buf = reader.readLine()) != null) {
					result += buf;
				}
			}
			return result;
		} catch (Exception e) {
			throw e;
		}
	}

	public static void main(String[] args) {
		// SFTPUtil sftp = new SFTPUtil("mysftp", "mysftp", "10.252.103.83",
		// 22);
		// try {
		// sftp.connect();
		// // List<Map<String, Object>> fileList = sftp.list();
		// // List<Map<String, Object>> fileList2 =
		// sftp.list("shenyang/20160512");
		// // System.out.println(fileList);
		// // System.out.println(File.separator);
		// // System.out.println(fileList2);
		// sftp.download("/shenyang/20160607/", "datas.zip",
		// "D:\\temp\\shenyang\\20160607\\datas.zip");
		// sftp.disconnect();
		// } catch (Exception e) {
		// // TODO Auto-generated catch block
		// e.printStackTrace();
		// }
		// System.out.println("/shenyang/".indexOf("/"));
		// Map<String, Object> map = new HashMap<String, Object>();
		// System.out.println(map.get("111"));

		// String zip = "111.zi1";
		// System.out.println(zip.lastIndexOf(".zip"));

		// BaseService bs = new BaseService();
		// File file = new File("D:\\temp\\\\fushun\\20160606\\");
		// System.out.println(bs.deleteDirRetain(file));
		// System.out.println(file.delete());
		// System.out.println(bs.deleteDirRetain(file));

	}
}
*/
